#include "UsartInitHelper.h"
#include "BufDef.h"
#include "GpioInitHelper.h"
#include "SimpleCompletion.h"

#include <string.h>
const char *get_data = "get send data!\n";

/** !\brief 中断函数表-开始
*
*/
/** !\brief 串口1中断回调函数
* 串口1 4G数据处理
*/
/* 串口1 发送完成1字节中断。 */
//void INT_SRC_USART1_TCI_IrqCallback(void) {
//  // 停止发送
//  USART_FuncCmd(CM_USART1, (USART_TX | USART_INT_TX_CPLT), DISABLE);

//  // 清理定时器
//  TMR0_Stop(CM_TMR0_1, TMR0_CH_A);

//  USART_ClearStatus(CM_USART1, USART_FLAG_RX_TIMEOUT);

//  USART_FuncCmd(CM_USART1, USART_RX_TIMEOUT, ENABLE);

//  // 清除发送完成中断标志
//  USART_ClearStatus(CM_USART1, USART_FLAG_TX_CPLT);
//}

///**
// * @brief  DMA1 CH0 串口1接收完成中断
// * @param  None
// * @retval None
// */
//void INT_SRC_DMA1_TC0_IrqCallback(void) {
//  USART_FuncCmd(CM_USART1, USART_RX_TIMEOUT, DISABLE);

//  DMA_ClearTransCompleteStatus(CM_DMA1, DMA_FLAG_TC_CH0);
//}

///**
// * @brief  DMA1 CH1 串口1发送完成中断
// * @param  None
// * @retval None
// */
//void INT_SRC_DMA1_TC1_IrqCallback(void) {
//  // 这里要重启一下中断。因为发送完成之后中断不生效就没法触发下一次发送
//  // 刚初始化完成时会触发一次这个中断
//  // 恢复发送中断。准备下次传输
//  USART_FuncCmd(CM_USART1, USART_INT_TX_CPLT, ENABLE);

//  // 清除DMA发送完成状态
//  DMA_ClearTransCompleteStatus(CM_DMA1, DMA_FLAG_TC_CH1);

//  led_busy_times = 4;
//  memset(mqtt_usart_tx_buf, 0, sizeof(mqtt_usart_tx_buf));
//  rt_sem_release(mqtt_usart_tx_sem);
//}

///**
// * @brief  USART RX timeout IRQ callback.
// * @param  None
// * @retval None
// */
//void INT_SRC_USART1_RTO_IrqCallback(void) {
//  // 将接收到的发回
//  rt_mq_send_wait(&mqtt_usart_rx_msq, mqtt_usart_rx_buf, 1536, 500);
//  rt_memset(mqtt_usart_rx_buf, 0, 1536);
//  led_busy_times = 4;

//  // 清理状态
//  AOS_SW_Trigger();

//  TMR0_Stop(CM_TMR0_1, TMR0_CH_A);

//  USART_ClearStatus(CM_USART1, USART_FLAG_RX_TIMEOUT);
//}


/* INT_SRC_USART1_EI Callback. */
//void USART1_RxError_IrqHandler(void) {
//  //add your codes here
//  GPIO_SetPins(LED_ERR_PORT, LED_ERR_PIN);
//  (void) USART_ReadData(CM_USART1);

//  USART_ClearStatus(CM_USART1, (USART_FLAG_PARITY_ERR | USART_FLAG_FRAME_ERR | USART_FLAG_OVERRUN));
//  //DDL_DelayMS(1000UL);
//  //__NVIC_SystemReset();
//  //run_healthy = false;
//}
// 4G中断函数
/* 串口1中断回调函数 */

/** !\brief 串口2中断回调函数
* 串口2 北斗数据处理
*/
/* 串口2 发送完成1字节中断。 */
void INT_SRC_USART2_TCI_IrqCallback(void) {
  // 停止发送
  USART_FuncCmd(CM_USART2, (USART_TX | USART_INT_TX_CPLT), DISABLE);

  // 清理定时器
  TMR0_Stop(CM_TMR0_1, TMR0_CH_B);

  USART_ClearStatus(CM_USART2, USART_FLAG_RX_TIMEOUT);

  USART_FuncCmd(CM_USART2, USART_RX_TIMEOUT, ENABLE);

  // 清除发送完成中断标志
  USART_ClearStatus(CM_USART2, USART_FLAG_TX_CPLT);
}


/**
 * @brief  DMA1 CH3 串口2接收完成中断
 * @param  None
 * @retval None
 */
//void INT_SRC_DMA1_TC3_IrqCallback(void) {

//  USART_FuncCmd(CM_USART2, USART_RX_TIMEOUT, DISABLE);

//  DMA_ClearTransCompleteStatus(CM_DMA1, DMA_FLAG_TC_CH3);
//}


/**
 * @brief  DMA2 CH6 串口2发送完成中断
 * @param  None
 * @retval None
 */
void INT_SRC_DMA2_TC6_IrqCallback(void) {
  // 这里要重启一下中断。因为发送完成之后中断不生效就没法触发下一次发送
  // 刚初始化完成时会触发一次这个中断
  // 恢复发送中断。准备下次传输
  USART_FuncCmd(CM_USART2, USART_INT_TX_CPLT, ENABLE);

  // 清除DMA发送完成状态
  DMA_ClearTransCompleteStatus(CM_DMA2, DMA_FLAG_TC_CH6);
  // 信号量只有两个状态，是否为0
  //rt_sem_release(debug_usart_sem);
}

/**
 * @brief  USART RX timeout IRQ callback.
 * @param  None
 * @retval None
 */
//void INT_SRC_USART2_RTO_IrqCallback(void) {
//  //    if (m_enRxFrameEnd != SET) {
//  //        m_enRxFrameEnd = SET;
//  //        m_u16RxLen = APP_FRAME_LEN_MAX - (uint16_t)DMA_GetTransCount(CM_DMA1, DMA_FLAG_TC_CH2);

//  //        /* Trigger for re-config USART RX DMA */
//  //
//  //    }
//  //rt_mq_send_wait(&gnss_usart_msq, gnss_usart_rx_buf, 1536, 500);
//  //rt_memset(gnss_usart_rx_buf, 0, 1536);
//  AOS_SW_Trigger();

//  TMR0_Stop(CM_TMR0_1, TMR0_CH_B);

//  USART_ClearStatus(CM_USART2, USART_FLAG_RX_TIMEOUT);
//}


/* INT_SRC_USART2_EI Callback. */
void USART2_RxError_IrqHandler(void) {
  //add your codes here
  (void) USART_ReadData(CM_USART2);

  USART_ClearStatus(CM_USART2, (USART_FLAG_PARITY_ERR | USART_FLAG_FRAME_ERR | USART_FLAG_OVERRUN));
  //DDL_DelayMS(1000UL);
  //__NVIC_SystemReset();
  //run_healthy = false;
}
/* 北斗消息回调 */
/* 串口2中断回调函数 */

/** !\brief 串口3中断回调函数
* 串口3 控制台数据处理
*/
/* 串口3 发送完成1字节中断。 */
void INT_SRC_USART3_TCI_IrqCallback(void) {
  // 停止发送
  USART_FuncCmd(CM_USART3, (USART_TX | USART_INT_TX_CPLT), DISABLE);

  // 清理定时器
  // 警告，如果没有rx timeout的串口这三条超时一定要关了。否则会造成串口异常。
  //TMR0_Stop(CM_TMR0_1, TMR0_CH_A);

  //USART_ClearStatus(CM_USART3, USART_FLAG_RX_TIMEOUT);

  //USART_FuncCmd(CM_USART3, USART_RX_TIMEOUT, ENABLE);

  // 清除发送完成中断标志
  USART_ClearStatus(CM_USART3, USART_FLAG_TX_CPLT);
}

/**
 * @brief  USART RX IRQ callback
 * @param  None
 * @retval None
 */
// 串口3接收完成回调
uint16_t u1_read_buf_16;
void INT_SRC_USART3_RI_IrqCallback(void) {
  rt_interrupt_enter();
  u1_read_buf_16 = (uint8_t) USART_ReadData(CM_USART1);
  usart_1_tx_msq_buf[u1_rx_size] = u1_read_buf_16 & 0xFF;
  u1_rx_size += 1;
  if (u1_rx_size >= 1024) {
    // 接收缓冲区满处理
    u1_rx_size = 0;
    // 处理接收内容。
  }

  //rt_mq_send_wait(&finsh_usart_mq, (void*)usart_1_tx_msq_buf, 1, 1500);
  rt_interrupt_leave();//在中断中一定要调用这对函数，离开中断
}

/**
 * @brief  DMA1 CH0 串口3发送完成中断
 * @param  None
 * @retval None
 */
void INT_SRC_DMA1_TC0_IrqCallback(void) {
  // 这里要重启一下中断。因为发送完成之后中断不生效就没法触发下一次发送
  // 刚初始化完成时会触发一次这个中断
  // 恢复发送中断。准备下次传输
  USART_FuncCmd(CM_USART3, USART_INT_TX_CPLT, ENABLE);

  // 清除DMA发送完成状态
  DMA_ClearTransCompleteStatus(CM_DMA1, DMA_FLAG_TC_CH0);
  //GPIO_ResetPins(U2_EN_PORT, U2_EN_PIN);
  // 信号量只有两个状态，是否为0.因为信号量数量类型为uint16_t
  rt_sem_release(debug_usart_sem);
  // 这里不用上面的单次释放是因为这里按理说资源只有一个，应该只释放一次，但是确保释放干净，需要清空列表。
  //completion_done(debug_usart_sem);
}

/* INT_SRC_USART3_EI Callback. */
void USART3_RxError_IrqHandler(void) {
  //add your codes here
  GPIO_SetPins(LED_ERR_PORT, LED_ERR_PIN);
  (void) USART_ReadData(CM_USART3);

  USART_ClearStatus(CM_USART3, (USART_FLAG_PARITY_ERR | USART_FLAG_FRAME_ERR | USART_FLAG_OVERRUN));
  //DDL_DelayMS(1000UL);
  //__NVIC_SystemReset();
  //run_healthy = false;
}
/* 串口控制台回调 */
/* 串口3中断回调函数 */

/** !\brief 串口6中断回调函数
* 串口6 MEMS震动传感器数据处理
*/
/* 串口6中断回调函数 */
/* 串口6 发送完成1字节中断。 */
//void INT_SRC_USART6_TCI_IrqCallback(void) {
//  // 停止发送
//  USART_FuncCmd(CM_USART6, (USART_TX | USART_INT_TX_CPLT), DISABLE);

//  // 清理定时器
//  TMR0_Stop(CM_TMR0_2, TMR0_CH_A);

//  USART_ClearStatus(CM_USART6, USART_FLAG_RX_TIMEOUT);

//  USART_FuncCmd(CM_USART6, USART_RX_TIMEOUT, ENABLE);

//  // 清除发送完成中断标志
//  USART_ClearStatus(CM_USART6, USART_FLAG_TX_CPLT);
//}

/**
 * @brief  DMA1 CH2 串口6接收完成中断
 * @param  None
 * @retval None
 */
//void INT_SRC_USART6_RI_IrqCallback(void) {

//  USART_FuncCmd(CM_USART6, USART_RX_TIMEOUT, DISABLE);

//  DMA_ClearTransCompleteStatus(CM_DMA1, DMA_FLAG_TC_CH2);
//}

/**
 * @brief  DMA1 CH2 串口6接收完成中断
 * @param  None
 * @retval None
 */
//void INT_SRC_DMA1_TC2_IrqCallback(void) {

//  USART_FuncCmd(CM_USART6, USART_RX_TIMEOUT, DISABLE);

//  DMA_ClearTransCompleteStatus(CM_DMA1, DMA_FLAG_TC_CH2);
//}


/**
 * @brief  DMA2 CH7 串口6发送完成中断
 * @param  None
 * @retval None
 */
//void INT_SRC_DMA2_TC7_IrqCallback(void) {
//  // 这里要重启一下中断。因为发送完成之后中断不生效就没法触发下一次发送
//  // 刚初始化完成时会触发一次这个中断
//  // 恢复发送中断。准备下次传输
//  USART_FuncCmd(CM_USART6, USART_INT_TX_CPLT, ENABLE);

//  // 清除DMA发送完成状态
//  DMA_ClearTransCompleteStatus(CM_DMA2, DMA_FLAG_TC_CH7);

//  led_busy_times = 4;
//  //memset(mqtt_message_tx_buf, 0, sizeof(mqtt_message_tx_buf));
//  //rt_sem_release(mqtt_message_tx_sem);
//}

/**
 * @brief  USART RX timeout IRQ callback.
 * @param  None
 * @retval None
 */
//void INT_SRC_USART6_RTO_IrqCallback(void) {
//  // 将接收到的发回
//  //rt_mq_send_wait(&mqtt_message_rx_msq, mqtt_message_rx_buf, 1536, 500);
//  //rt_memset(mqtt_message_rx_buf, 0, 1536);
//  led_busy_times = 4;

//  // 清理状态
//  AOS_SW_Trigger();

//  TMR0_Stop(CM_TMR0_2, TMR0_CH_A);

//  USART_ClearStatus(CM_USART6, USART_FLAG_RX_TIMEOUT);
//}


/* INT_SRC_USART6_EI Callback. */
//void USART6_RxError_IrqHandler(void) {
//  //add your codes here
//  GPIO_SetPins(LED_ERR_PORT, LED_ERR_PIN);
//  (void) USART_ReadData(CM_USART6);

//  USART_ClearStatus(CM_USART6, (USART_FLAG_PARITY_ERR | USART_FLAG_FRAME_ERR | USART_FLAG_OVERRUN));
//  //DDL_DelayMS(1000UL);
//  //__NVIC_SystemReset();
//  //run_healthy = false;
//}
/* 串口6 MEMS震动传感器数据处理 */
/* 串口6中断回调函数 */

/** !\brief 串口9中断回调函数
* 串口9 RS485-3
*/
/* 串口9中断回调函数 */
/* 串口9 发送完成1字节中断。 */
void INT_SRC_USART9_TCI_IrqCallback(void) {
  // 停止发送
  USART_FuncCmd(CM_USART9, (USART_TX | USART_INT_TX_CPLT), DISABLE);

  // 清理定时器
//  TMR0_Stop(CM_TMR0_2, TMR0_CH_B);

//  USART_ClearStatus(CM_USART9, USART_FLAG_RX_TIMEOUT);

//  USART_FuncCmd(CM_USART9, USART_RX_TIMEOUT, ENABLE);

  // 清除发送完成中断标志
  USART_ClearStatus(CM_USART9, USART_FLAG_TX_CPLT);
}

/**
 * @brief  DMA1 CH1 串口9接收完成中断
 * @param  None
 * @retval None
 */
void INT_SRC_USART9_RI_IrqCallback(void) {

  //USART_FuncCmd(CM_USART9, USART_RX_TIMEOUT, DISABLE);

  DMA_ClearTransCompleteStatus(CM_DMA1, DMA_FLAG_TC_CH1);
  u9_rx_size += 1;
}

/**
 * @brief  DMA1 CH1 串口9接收完成中断
 * @param  None
 * @retval None
 */
void INT_SRC_DMA1_TC1_IrqCallback(void) {

  //USART_FuncCmd(CM_USART9, USART_RX_TIMEOUT, DISABLE);

  DMA_ClearTransCompleteStatus(CM_DMA1, DMA_FLAG_TC_CH1);
}


/**
 * @brief  DMA2 CH1 串口9发送完成中断
 * @param  None
 * @retval None
 */
void INT_SRC_DMA2_TC1_IrqCallback(void) {
  // 这里要重启一下中断。因为发送完成之后中断不生效就没法触发下一次发送
  // 刚初始化完成时会触发一次这个中断
  // 恢复发送中断。准备下次传输
  USART_FuncCmd(CM_USART9, USART_INT_TX_CPLT, ENABLE);

  // 清除DMA发送完成状态
  DMA_ClearTransCompleteStatus(CM_DMA2, DMA_FLAG_TC_CH1);

  led_busy_times = 4;
  //memset(mqtt_message_tx_buf, 0, sizeof(mqtt_message_tx_buf));
  rt_sem_release(rs485_3_usart_tx_sem);
}


/* INT_SRC_USART6_EI Callback. */
void USART9_RxError_IrqHandler(void) {
  //add your codes here
  GPIO_SetPins(LED_ERR_PORT, LED_ERR_PIN);
  (void) USART_ReadData(CM_USART9);

  USART_ClearStatus(CM_USART9, (USART_FLAG_PARITY_ERR | USART_FLAG_FRAME_ERR | USART_FLAG_OVERRUN));
  //DDL_DelayMS(1000UL);
  //__NVIC_SystemReset();
  //run_healthy = false;
}
/* 串口9 MEMS震动传感器数据处理 */
/* 串口9中断回调函数 */
// 中断函数表-结束

//Usart Config
void App_USARTxCfg(void) {
  // 共用的初始化结构体
  stc_usart_uart_init_t stcUartInit;

  {// 初始化串口2 北斗
    /* Enable peripheral clock */
    FCG_Fcg3PeriphClockCmd(FCG3_PERIPH_USART2, ENABLE);
    USART_DeInit(CM_USART2);
    /* Initialize UART. */
    (void) USART_UART_StructInit(&stcUartInit);
    stcUartInit.u32ClockSrc = USART_CLK_SRC_INTERNCLK;
    // 如果是低于115200这里要用DIV4，其他DIV1
    stcUartInit.u32ClockDiv = USART_CLK_DIV4;
    stcUartInit.u32CKOutput = USART_CK_OUTPUT_ENABLE;
    stcUartInit.u32Baudrate = 115200UL;
    stcUartInit.u32DataWidth = USART_DATA_WIDTH_8BIT;
    //stcUartInit.u32Parity = USART_PARITY_EVEN;
    stcUartInit.u32OverSampleBit = USART_OVER_SAMPLE_16BIT;
    stcUartInit.u32StopBit = USART_STOPBIT_1BIT;
    //stcUartInit.u32FirstBit = USART_FIRST_BIT_LSB;
    stcUartInit.u32StartBitPolarity = USART_START_BIT_FALLING;
    stcUartInit.u32HWFlowControl = USART_HW_FLOWCTRL_RTS;

    if (LL_OK != USART_UART_Init(CM_USART2, &stcUartInit, NULL)) {
      GPIO_SetPins(LED_ERR_PORT, LED_ERR_PIN);
      for (;;) {
      }
    } else {
      USART_FilterCmd(CM_USART2, ENABLE);
      /* Enable TX && RX && RX interrupt function */
      USART_FuncCmd(CM_USART2, (USART_RX | USART_INT_RX | USART_RX_TIMEOUT | USART_INT_RX_TIMEOUT), ENABLE);
      // | USART_INT_RX | USART_RX_TIMEOUT | USART_INT_RX_TIMEOUT
    }
  }// 初始化串口2

  {// 初始化串口3 控制台
    /* Enable peripheral clock */
    FCG_Fcg3PeriphClockCmd(FCG3_PERIPH_USART3, ENABLE);
    USART_DeInit(CM_USART3);
    /* Initialize UART. */
    (void) USART_UART_StructInit(&stcUartInit);
    stcUartInit.u32ClockSrc = USART_CLK_SRC_INTERNCLK;
    // 如果是低于115200这里要用DIV4，其他DIV1
    stcUartInit.u32ClockDiv = USART_CLK_DIV1;
    stcUartInit.u32CKOutput = USART_CK_OUTPUT_ENABLE;
    stcUartInit.u32Baudrate = 1843200UL;
    stcUartInit.u32DataWidth = USART_DATA_WIDTH_8BIT;
    //stcUartInit.u32Parity = USART_PARITY_EVEN;
    stcUartInit.u32OverSampleBit = USART_OVER_SAMPLE_16BIT;
    stcUartInit.u32StopBit = USART_STOPBIT_1BIT;
    //stcUartInit.u32FirstBit = USART_FIRST_BIT_LSB;
    stcUartInit.u32StartBitPolarity = USART_START_BIT_FALLING;
    stcUartInit.u32HWFlowControl = USART_HW_FLOWCTRL_NONE;

    if (LL_OK != USART_UART_Init(CM_USART3, &stcUartInit, NULL)) {
      GPIO_SetPins(LED_RUN_PORT, LED_RUN_PIN);
      for (;;) {
      }
    } else {
      USART_FilterCmd(CM_USART3, ENABLE);
      /* Enable TX && RX && RX interrupt function */
      USART_FuncCmd(CM_USART3, (USART_RX | USART_INT_RX), ENABLE);
      // | USART_INT_RX | USART_RX_TIMEOUT | USART_INT_RX_TIMEOUT USART_INT_RX
    }
  }// 初始化串口3


  //  { // 初始化串口6 MEMS震动传感器
  //    /* Enable peripheral clock */
  //    FCG_Fcg3PeriphClockCmd(FCG3_PERIPH_USART6, ENABLE);
  //    USART_DeInit(CM_USART6);
  //    /* Initialize UART. */
  //    (void) USART_UART_StructInit(&stcUartInit);
  //    stcUartInit.u32ClockSrc = USART_CLK_SRC_INTERNCLK;
  //    // 如果是低于115200这里要用DIV4，其他DIV1
  //    stcUartInit.u32ClockDiv = USART_CLK_DIV4;
  //    stcUartInit.u32CKOutput = USART_CK_OUTPUT_ENABLE;
  //    stcUartInit.u32Baudrate = 9600UL;
  //    stcUartInit.u32DataWidth = USART_DATA_WIDTH_8BIT;
  //    //stcUartInit.u32Parity = USART_PARITY_EVEN;
  //    stcUartInit.u32OverSampleBit = USART_OVER_SAMPLE_16BIT;
  //    stcUartInit.u32StopBit = USART_STOPBIT_1BIT;
  //    //stcUartInit.u32FirstBit = USART_FIRST_BIT_LSB;
  //    stcUartInit.u32StartBitPolarity = USART_START_BIT_FALLING;
  //    stcUartInit.u32HWFlowControl = USART_HW_FLOWCTRL_NONE;

  //    if (LL_OK != USART_UART_Init(CM_USART6, &stcUartInit, NULL)) {
  //      GPIO_SetPins(LED_ERR_PORT, LED_ERR_PIN);
  //      for (;;) {
  //      }
  //    } else {
  //      USART_FilterCmd(CM_USART6, ENABLE);
  //      /* Enable TX && RX && RX interrupt function */
  //      USART_FuncCmd(CM_USART6, (USART_RX | USART_INT_RX | USART_RX_TIMEOUT | USART_INT_RX_TIMEOUT), ENABLE);
  //      // | USART_INT_RX | USART_RX_TIMEOUT | USART_INT_RX_TIMEOUT
  //    }
  //  }// 初始化串口6

  {// 初始化串口9 RS485-3
    /* Enable USART9 clock */
    FCG_Fcg3PeriphClockCmd(FCG3_PERIPH_USART9, ENABLE);
    /************************* Configure USART9***************************/
    USART_DeInit(CM_USART9);
    (void) USART_UART_StructInit(&stcUartInit);
    stcUartInit.u32ClockSrc = USART_CLK_SRC_INTERNCLK;
    stcUartInit.u32ClockDiv = USART_CLK_DIV4;
    stcUartInit.u32CKOutput = USART_CK_OUTPUT_DISABLE;
    stcUartInit.u32Baudrate = 9600UL;
    stcUartInit.u32DataWidth = USART_DATA_WIDTH_8BIT;
    stcUartInit.u32StopBit = USART_STOPBIT_1BIT;
    stcUartInit.u32Parity = USART_PARITY_NONE;
    stcUartInit.u32OverSampleBit = USART_OVER_SAMPLE_16BIT;
    //    stcUartInit.u32FirstBit = USART_FIRST_BIT_LSB;
    stcUartInit.u32StartBitPolarity = USART_START_BIT_FALLING;
    //stcUartInit.u32HWFlowControl = USART_HW_FLOWCTRL_RTS;
    if (LL_OK != USART_UART_Init(CM_USART9, &stcUartInit, NULL)) {
      GPIO_SetPins(LED_RUN_PORT, LED_RUN_PIN);
      for (;;) {
		  SWDT_FeedDog();
      }
    } else {
      USART_FilterCmd(CM_USART9, ENABLE);
      /* Enable USART_TX | USART_RX | USART_INT_TX_CPLT | USART_INT_RX function */
      //USART_FuncCmd(CM_USART9, (USART_RX | USART_INT_RX), ENABLE);
      USART_FuncCmd(CM_USART9, (USART_RX | USART_INT_RX), ENABLE);
      // | USART_INT_RX | USART_RX_TIMEOUT | USART_INT_RX_TIMEOUT
    }

  }// 初始化串口9
}

/* 初始化RS485-3运行环境 */
// rs495-3接收邮箱
extern struct rt_messagequeue rs485_3_usart_rx_mq;
bool Init_Rs485_3_Usart_Env(void) {
	u9_rx_size = 0;
  // rs485-3发送信号
  rs485_3_usart_tx_sem = rt_sem_create("rs485_3_usart_tx_sem", 0, RT_IPC_FLAG_PRIO);
  // rs485-3接收信号
  rs485_3_usart_rx_sem = rt_sem_create("rs485_3_usart_rx_sem", 0, RT_IPC_FLAG_PRIO);
  // 用于创建没有接收定时器的串口接收定时信号

  rt_mq_init(&rs485_3_usart_rx_mq,
             "rs485_3_usart_rx_mq",
             &usart_9_rx_msq_pool[0], /* 内存池指向 msg_pool */
             1024,                    /* 每个消息的大小是 1 字节 */
             4096,                    /* 内存池的大小是 msg_pool 的大小 */
             RT_IPC_FLAG_PRIO);       /* 如果有多个线程等待，优先级大小的方法分配消息 */

  SWDT_FeedDog();
  return true;
}
/* 初始化rs485-3控制变量 */
